make use of QStringLiteral with QXmlStreamWriter. (#153)

diff --git a/garmin_fs.cc b/garmin_fs.cc
index e30c3e9aa3c83f9e3a24e2a1f643faab4cb6d3ae..0e648b27853ead7fc0795bc93274103e05049a4f 100644 (file)
--- a/garmin_fs.cc
+++ b/garmin_fs.cc
@@ -214,18 +214,18 @@ garmin_fs_xml_fprint(const Waypoint* waypt,
       WAYPT_HAS(waypt, proximity) ||
       WAYPT_HAS(waypt, temperature) ||
       gmsd->flags.display) {
-    writer->writeStartElement("extensions");
-    writer->writeStartElement("gpxx:WaypointExtension");
-    writer->writeNamespace("http://www.garmin.com/xmlschemas/GpxExtensions/v3",
+    writer->writeStartElement(QStringLiteral("extensions"));
+    writer->writeStartElement(QStringLiteral("gpxx:WaypointExtension"));
+    writer->writeNamespace(QStringLiteral("http://www.garmin.com/xmlschemas/GpxExtensions/v3"),
                            "gpxx");
     if WAYPT_HAS(waypt, proximity) {
-      writer->writeTextElement("gpxx:Proximity", QString::number(waypt->proximity, 'f', 6));
+      writer->writeTextElement(QStringLiteral("gpxx:Proximity"), QString::number(waypt->proximity, 'f', 6));
     }
     if WAYPT_HAS(waypt, temperature) {
-      writer->writeTextElement("gpxx:Temperature",  QString::number(waypt->temperature, 'f', 6));
+      writer->writeTextElement(QStringLiteral("gpxx:Temperature"),  QString::number(waypt->temperature, 'f', 6));
     }
     if WAYPT_HAS(waypt, depth) {
-      writer->writeTextElement("gpxx:Depth", QString::number(waypt->depth, 'f', 6));
+      writer->writeTextElement(QStringLiteral("gpxx:Depth"), QString::number(waypt->depth, 'f', 6));
     }
     if (gmsd->flags.display) {
       const char* cx;
@@ -240,15 +240,15 @@ garmin_fs_xml_fprint(const Waypoint* waypt,
         cx = "SymbolAndName";
         break;
       }
-      writer->writeTextElement("gpxx:DisplayMode", cx);
+      writer->writeTextElement(QStringLiteral("gpxx:DisplayMode"), cx);
     }
     if (gmsd->flags.category && gmsd->category) {
       int i;
       uint16_t cx = gmsd->category;
-      writer->writeStartElement("gpxx:Categories");
+      writer->writeStartElement(QStringLiteral("gpxx:Categories"));
       for (i = 0; i < 16; i++) {
         if (cx & 1) {
-          writer->writeTextElement("gpxx:Category", QString("Category %1").arg(i+1));
+          writer->writeTextElement(QStringLiteral("gpxx:Category"), QStringLiteral("Category %1").arg(i+1));
         }
         cx = cx >> 1;
       }
@@ -256,28 +256,28 @@ garmin_fs_xml_fprint(const Waypoint* waypt,
     }
     if (*addr) {
       char* str;
-      writer->writeStartElement("gpxx:Address");
+      writer->writeStartElement(QStringLiteral("gpxx:Address"));
 
       if ((str = GMSD_GET(addr, NULL))) {
-        writer->writeTextElement("gpxx:StreetAddress", str);
+        writer->writeTextElement(QStringLiteral("gpxx:StreetAddress"), str);
       }
       if ((str = GMSD_GET(city, NULL))) {
-        writer->writeTextElement("gpxx:City", str);
+        writer->writeTextElement(QStringLiteral("gpxx:City"), str);
       }
       if ((str = GMSD_GET(state, NULL))) {
-        writer->writeTextElement("gpxx:State", str);
+        writer->writeTextElement(QStringLiteral("gpxx:State"), str);
       }
       if ((str = GMSD_GET(country, NULL))) {
-        writer->writeTextElement("gpxx:Country", str);
+        writer->writeTextElement(QStringLiteral("gpxx:Country"), str);
       }
       if ((str = GMSD_GET(postal_code, NULL))) {
-        writer->writeTextElement("gpxx:PostalCode", str);
+        writer->writeTextElement(QStringLiteral("gpxx:PostalCode"), str);
       }
       writer->writeEndElement(); // /gpxx::Address
     }
 
     if (*phone) {
-      writer->writeTextElement("gpxx:PhoneNumber", phone);
+      writer->writeTextElement(QStringLiteral("gpxx:PhoneNumber"), phone);
     }
 
     writer->writeEndElement(); // /gpxx::WaypointExtension

diff --git a/geo.cc b/geo.cc
index 87572fa77641a2cc262efee0e1e4d9c59aafc5e1..e95f9e875f0a4c36aaa8a0fb62a36ebdd0ba4c22 100644 (file)
--- a/geo.cc
+++ b/geo.cc
@@ -179,34 +179,34 @@ geo_wr_deinit()
 static void
 geo_waypt_pr(const Waypoint* waypointp)
 {
-  writer.writeStartElement("waypoint");
+  writer.writeStartElement(QStringLiteral("waypoint"));
 
-  writer.writeStartElement("name");
-  writer.writeAttribute("id", waypointp->shortname);
+  writer.writeStartElement(QStringLiteral("name"));
+  writer.writeAttribute(QStringLiteral("id"), waypointp->shortname);
   // TODO: this could be writeCharacters, but it's here for compat with pre
   // Qt writer.
   writer.writeCDATA(waypointp->description);
   writer.writeEndElement();
 
-  writer.writeStartElement("coord");
-  writer.writeAttribute("lat", QString::number(waypointp->latitude, 'f'));
-  writer.writeAttribute("lon", QString::number(waypointp->longitude, 'f'));
+  writer.writeStartElement(QStringLiteral("coord"));
+  writer.writeAttribute(QStringLiteral("lat"), QString::number(waypointp->latitude, 'f'));
+  writer.writeAttribute(QStringLiteral("lon"), QString::number(waypointp->longitude, 'f'));
   writer.writeEndElement();
 
-  writer.writeTextElement("type", deficon ? deficon : waypointp->icon_descr);
+  writer.writeTextElement(QStringLiteral("type"), deficon ? deficon : waypointp->icon_descr);
 
   if (waypointp->HasUrlLink()) {
-    writer.writeStartElement("link");
-    writer.writeAttribute("text ", "Cache Details");
+    writer.writeStartElement(QStringLiteral("link"));
+    writer.writeAttribute(QStringLiteral("text "), QStringLiteral("Cache Details"));
     UrlLink link = waypointp->GetUrlLink();
     writer.writeCharacters(link.url_);
     writer.writeEndElement();
   }
 
   if (waypointp->gc_data && waypointp->gc_data->diff) {
-    writer.writeTextElement("difficulty",
+    writer.writeTextElement(QStringLiteral("difficulty"),
                             QString::number(waypointp->gc_data->diff/10));
-    writer.writeTextElement("terrain",
+    writer.writeTextElement(QStringLiteral("terrain"),
                             QString::number(waypointp->gc_data->terr/10));
 
     int v = 1;
@@ -236,7 +236,7 @@ geo_waypt_pr(const Waypoint* waypointp)
       v = 1;
       break;
     }
-    writer.writeTextElement("container",
+    writer.writeTextElement(QStringLiteral("container"),
                             QString::number(v));
   }
 
@@ -246,12 +246,12 @@ geo_waypt_pr(const Waypoint* waypointp)
 static void
 geo_write()
 {
-  writer.writeStartElement("loc");
-  writer.writeAttribute("version", "1.0");
+  writer.writeStartElement(QStringLiteral("loc"));
+  writer.writeAttribute(QStringLiteral("version"), QStringLiteral("1.0"));
   // TODO: This could be moved to wr_init, but the pre GPX version put the two
   // lines above this, so mimic that behaviour exactly.
   writer.setAutoFormatting(true);
-  writer.writeAttribute("src", "EasyGPS");
+  writer.writeAttribute(QStringLiteral("src"), QStringLiteral("EasyGPS"));
   waypt_disp_all(geo_waypt_pr);
   writer.writeEndElement();
 }

diff --git a/glogbook.cc b/glogbook.cc
index e7abccee9078af440b90fdc62faeb71d5721ab9e..6fb07f61fa025e7f1c4cc58042eda45deac659f6 100644 (file)
--- a/glogbook.cc
+++ b/glogbook.cc
@@ -99,22 +99,22 @@ glogbook_wr_deinit()
 static void
 glogbook_waypt_pr(const Waypoint* wpt)
 {
-  writer.writeStartElement("Trackpoint");
+  writer.writeStartElement(QStringLiteral("Trackpoint"));
 
-  writer.writeStartElement("Position");
-  writer.writeTextElement("Latitude", QString::number(wpt->latitude,'f', 5));
-  writer.writeTextElement("Longitude", QString::number(wpt->longitude,'f', 5));
-  writer.writeTextElement("Altitude", QString::number(wpt->altitude,'f', 3));
+  writer.writeStartElement(QStringLiteral("Position"));
+  writer.writeTextElement(QStringLiteral("Latitude"), QString::number(wpt->latitude,'f', 5));
+  writer.writeTextElement(QStringLiteral("Longitude"), QString::number(wpt->longitude,'f', 5));
+  writer.writeTextElement(QStringLiteral("Altitude"), QString::number(wpt->altitude,'f', 3));
   writer.writeEndElement(); // Position
 
-  writer.writeTextElement("Time", wpt->GetCreationTime().toPrettyString());
+  writer.writeTextElement(QStringLiteral("Time"), wpt->GetCreationTime().toPrettyString());
   writer.writeEndElement(); // Trackpoint
 }
 
 static void
 glogbook_hdr(const route_head*)
 {
-  writer.writeStartElement("Track");
+  writer.writeStartElement(QStringLiteral("Track"));
 }
 
 static void
@@ -131,8 +131,8 @@ glogbook_write()
   gbfprintf(ofd, "<History xmlns=\"http://www.garmin.com/xmlschemas/ForerunnerLogbook\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://www.garmin.com/xmlschemas/ForerunnerLogbook http://www.garmin.com/xmlschemas/ForerunnerLogbookv1.xsd\" version=\"1\">\n");
   gbfprintf(ofd, "    <Run>\n");
 #else
-  writer.writeStartElement("History");
-  writer.writeStartElement("Run");
+  writer.writeStartElement(QStringLiteral("History"));
+  writer.writeStartElement(QStringLiteral("Run"));
 #endif
   track_disp_all(glogbook_hdr, glogbook_ftr, glogbook_waypt_pr);
   writer.writeEndElement(); // Run

diff --git a/gpx.cc b/gpx.cc
index 4318f2e08a35acc8624322c6e0b9ce83050a8211..0375092641772b43d087fa2b13ff5aca9716a120 100644 (file)
--- a/gpx.cc
+++ b/gpx.cc
@@ -1274,27 +1274,27 @@ gpx_wr_init(const QString& fname)
   // to include just enough whitespace between <xml/> and <gpx...> to pass
   // diff -w.  It's here for now to shim compatibility with our zillion
   // reference files, but this blank link can go away some day.
-  writer->writeCharacters("\n");
+  writer->writeCharacters(QStringLiteral("\n"));
 
   writer->setAutoFormatting(true);
-  writer->writeStartElement("gpx");
-  writer->writeAttribute("version", gpx_wversion);
-  writer->writeAttribute("creator", CREATOR_NAME_URL);
-  writer->writeAttribute("xmlns", QString("http://www.topografix.com/GPX/%1/%2").arg(gpx_wversion[0]).arg(gpx_wversion[2]));
+  writer->writeStartElement(QStringLiteral("gpx"));
+  writer->writeAttribute(QStringLiteral("version"), gpx_wversion);
+  writer->writeAttribute(QStringLiteral("creator"), CREATOR_NAME_URL);
+  writer->writeAttribute(QStringLiteral("xmlns"), QStringLiteral("http://www.topografix.com/GPX/%1/%2").arg(gpx_wversion[0]).arg(gpx_wversion[2]));
   if (opt_humminbirdext || opt_garminext) {
     if (opt_humminbirdext) {
-      writer->writeAttribute("xmlns:h","http://humminbird.com");
+      writer->writeAttribute(QStringLiteral("xmlns:h"), QStringLiteral("http://humminbird.com"));
     }
     if (opt_garminext) {
-      writer->writeAttribute("xmlns:gpxx", "http://www.garmin.com/xmlschemas/GpxExtensions/v3");
-      writer->writeAttribute("xmlns:gpxtpx", "http://www.garmin.com/xmlschemas/TrackPointExtension/v1");
+      writer->writeAttribute(QStringLiteral("xmlns:gpxx"), QStringLiteral("http://www.garmin.com/xmlschemas/GpxExtensions/v3"));
+      writer->writeAttribute(QStringLiteral("xmlns:gpxtpx"), QStringLiteral("http://www.garmin.com/xmlschemas/TrackPointExtension/v1"));
     }
   } else {
     writer->writeAttributes(gpx_namespace_attribute);
   }
 
   if (gpx_wversion_num > 10) {
-    writer->writeStartElement("metadata");
+    writer->writeStartElement(QStringLiteral("metadata"));
   }
   if (gpx_global) {
     gpx_write_gdata(&gpx_global->name, "name");
@@ -1318,7 +1318,7 @@ gpx_wr_init(const QString& fname)
   }
 
   gpsbabel::DateTime now = current_time();
-  writer->writeTextElement("time", now.toPrettyString());
+  writer->writeTextElement(QStringLiteral("time"), now.toPrettyString());
 
   if (gpx_global) {
     gpx_write_gdata(&gpx_global->keywords, "keywords");
@@ -1444,7 +1444,7 @@ fprint_xml_chain(xml_tag* tag, const Waypoint* wpt)
       }
       if (wpt && wpt->gc_data->exported.isValid() &&
           tag->tagname.compare(QLatin1String("groundspeak:cache")) == 0) {
-        writer->writeTextElement("time",
+        writer->writeTextElement(QStringLiteral("time"),
                                  wpt->gc_data->exported.toPrettyString());
       }
       writer->writeEndElement();
@@ -1495,17 +1495,17 @@ write_gpx_url(const Waypoint* waypointp)
 
   if (gpx_wversion_num > 10) {
     foreach(UrlLink l, waypointp->GetUrlLinks()) {
-      writer->writeStartElement("link");
-      writer->writeAttribute("href", l.url_);
-      writer->writeOptionalTextElement("text", l.url_link_text_);
-      writer->writeOptionalTextElement("type", l.url_link_type_);
+      writer->writeStartElement(QStringLiteral("link"));
+      writer->writeAttribute(QStringLiteral("href"), l.url_);
+      writer->writeOptionalTextElement(QStringLiteral("text"), l.url_link_text_);
+      writer->writeOptionalTextElement(QStringLiteral("type"), l.url_link_type_);
       writer->writeEndElement();
     }
     return;
   }
   UrlLink l = waypointp->GetUrlLink();
-  writer->writeTextElement("url", QString(urlbase) + QString(l.url_));
-  writer->writeOptionalTextElement("urlname", QString(l.url_link_text_));
+  writer->writeTextElement(QStringLiteral("url"), QString(urlbase) + l.url_);
+  writer->writeOptionalTextElement(QStringLiteral("urlname"), l.url_link_text_);
 }
 
 /*
@@ -1541,19 +1541,19 @@ gpx_write_common_acc(const Waypoint* waypointp)
   }
 
   if (fix) {
-    writer->writeTextElement("fix", fix);
+    writer->writeTextElement(QStringLiteral("fix"), fix);
   }
   if (waypointp->sat > 0) {
-    writer->writeTextElement("sat", QString::number(waypointp->sat));
+    writer->writeTextElement(QStringLiteral("sat"), QString::number(waypointp->sat));
   }
   if (waypointp->hdop) {
-    writer->writeTextElement("hdop", toString(waypointp->hdop));
+    writer->writeTextElement(QStringLiteral("hdop"), toString(waypointp->hdop));
   }
   if (waypointp->vdop) {
-    writer->writeTextElement("vdop", toString(waypointp->vdop));
+    writer->writeTextElement(QStringLiteral("vdop"), toString(waypointp->vdop));
   }
   if (waypointp->pdop) {
-    writer->writeTextElement("pdop", toString(waypointp->pdop));
+    writer->writeTextElement(QStringLiteral("pdop"), toString(waypointp->pdop));
   }
   /* TODO: ageofdgpsdata should go here */
   /* TODO: dgpsid should go here */
@@ -1564,22 +1564,22 @@ static void
 gpx_write_common_position(const Waypoint* waypointp, const gpx_point_type point_type)
 {
   if (waypointp->altitude != unknown_alt) {
-    writer->writeTextElement("ele", QString::number(waypointp->altitude, 'f', elevation_precision));
+    writer->writeTextElement(QStringLiteral("ele"), QString::number(waypointp->altitude, 'f', elevation_precision));
   }
   QString t = waypointp->CreationTimeXML();
-  writer->writeOptionalTextElement("time", t);
+  writer->writeOptionalTextElement(QStringLiteral("time"), t);
   if (gpxpt_track==point_type && 10 == gpx_wversion_num) {
     /* These were accidentally removed from 1.1, and were only a part of trkpts in 1.0 */
     if WAYPT_HAS(waypointp, course) {
-      writer->writeTextElement("course", toString(waypointp->course));
+      writer->writeTextElement(QStringLiteral("course"), toString(waypointp->course));
     }
     if WAYPT_HAS(waypointp, speed) {
-      writer->writeTextElement("speed", toString(waypointp->speed));
+      writer->writeTextElement(QStringLiteral("speed"), toString(waypointp->speed));
     }
   }
   /* TODO:  magvar should go here */
   if (WAYPT_HAS(waypointp, geoidheight)) {
-    writer->writeOptionalTextElement("geoidheight",QString::number(waypointp->geoidheight, 'f', 1));
+    writer->writeOptionalTextElement(QStringLiteral("geoidheight"),QString::number(waypointp->geoidheight, 'f', 1));
   }
 }
 
@@ -1590,14 +1590,14 @@ gpx_write_common_extensions(const Waypoint* waypointp, const gpx_point_type poin
   if ((opt_humminbirdext && (WAYPT_HAS(waypointp, depth) || WAYPT_HAS(waypointp, temperature))) ||
       (opt_garminext && gpxpt_waypoint==point_type && (WAYPT_HAS(waypointp, proximity) || WAYPT_HAS(waypointp, temperature) || WAYPT_HAS(waypointp, depth))) ||
       (opt_garminext && gpxpt_track==point_type && (WAYPT_HAS(waypointp, temperature) || WAYPT_HAS(waypointp, depth) || waypointp->heartrate != 0 || waypointp->cadence != 0))) {
-    writer->writeStartElement("extensions");
+    writer->writeStartElement(QStringLiteral("extensions"));
 
     if (opt_humminbirdext) {
       if (WAYPT_HAS(waypointp, depth)) {
-        writer->writeTextElement("h:depth", toString(waypointp->depth * 100.0));
+        writer->writeTextElement(QStringLiteral("h:depth"), toString(waypointp->depth * 100.0));
       }
       if (WAYPT_HAS(waypointp, temperature)) {
-        writer->writeTextElement("h:temperature", toString(waypointp->temperature));
+        writer->writeTextElement(QStringLiteral("h:temperature"), toString(waypointp->temperature));
       }
     }
 
@@ -1609,15 +1609,15 @@ gpx_write_common_extensions(const Waypoint* waypointp, const gpx_point_type poin
       switch (point_type) {
       case gpxpt_waypoint:
         if (WAYPT_HAS(waypointp, proximity) || WAYPT_HAS(waypointp, temperature) || WAYPT_HAS(waypointp, depth)) {
-          writer->writeStartElement("gpxx:WaypointExtension");
+          writer->writeStartElement(QStringLiteral("gpxx:WaypointExtension"));
           if (WAYPT_HAS(waypointp, proximity)) {
-            writer->writeTextElement("gpxx:Proximity", toString(waypointp->proximity));
+            writer->writeTextElement(QStringLiteral("gpxx:Proximity"), toString(waypointp->proximity));
           }
           if (WAYPT_HAS(waypointp, temperature)) {
-            writer->writeTextElement("gpxx:Temperature", toString(waypointp->temperature));
+            writer->writeTextElement(QStringLiteral("gpxx:Temperature"), toString(waypointp->temperature));
           }
           if (WAYPT_HAS(waypointp, depth)) {
-            writer->writeTextElement("gpxx:Depth", toString(waypointp->depth));
+            writer->writeTextElement(QStringLiteral("gpxx:Depth"), toString(waypointp->depth));
           }
           writer->writeEndElement(); // "gpxx:WaypointExtension"
         }
@@ -1628,18 +1628,18 @@ gpx_write_common_extensions(const Waypoint* waypointp, const gpx_point_type poin
       case gpxpt_track:
         if (WAYPT_HAS(waypointp, temperature) || WAYPT_HAS(waypointp, depth) || waypointp->heartrate != 0 || waypointp->cadence != 0) {
           // gpxtpx:TrackPointExtension is a replacement for gpxx:TrackPointExtension.
-          writer->writeStartElement("gpxtpx:TrackPointExtension");
+          writer->writeStartElement(QStringLiteral("gpxtpx:TrackPointExtension"));
           if (WAYPT_HAS(waypointp, temperature)) {
-            writer->writeTextElement("gpxtpx:atemp", toString(waypointp->temperature));
+            writer->writeTextElement(QStringLiteral("gpxtpx:atemp"), toString(waypointp->temperature));
           }
           if (WAYPT_HAS(waypointp, depth)) {
-            writer->writeTextElement("gpxtpx:depth", toString(waypointp->depth));
+            writer->writeTextElement(QStringLiteral("gpxtpx:depth"), toString(waypointp->depth));
           }
           if (waypointp->heartrate != 0) {
-            writer->writeTextElement("gpxtpx:hr", QString::number(waypointp->heartrate));
+            writer->writeTextElement(QStringLiteral("gpxtpx:hr"), QString::number(waypointp->heartrate));
           }
           if (waypointp->cadence != 0) {
-            writer->writeTextElement("gpxtpx:cad", QString::number(waypointp->cadence));
+            writer->writeTextElement(QStringLiteral("gpxtpx:cad"), QString::number(waypointp->cadence));
           }
           writer->writeEndElement(); // "gpxtpx:TrackPointExtension"
         }
@@ -1654,17 +1654,17 @@ gpx_write_common_extensions(const Waypoint* waypointp, const gpx_point_type poin
 static void
 gpx_write_common_description(const Waypoint* waypointp, QString oname)
 {
-  writer->writeOptionalTextElement("name", oname);
+  writer->writeOptionalTextElement(QStringLiteral("name"), oname);
 
-  writer->writeOptionalTextElement("cmt", waypointp->description);
+  writer->writeOptionalTextElement(QStringLiteral("cmt"), waypointp->description);
   if (!waypointp->notes.isEmpty()) {
-    writer->writeTextElement("desc", waypointp->notes);
+    writer->writeTextElement(QStringLiteral("desc"), waypointp->notes);
   } else {
-    writer->writeOptionalTextElement("desc", waypointp->description);
+    writer->writeOptionalTextElement(QStringLiteral("desc"), waypointp->description);
   }
   /* TODO: src should go here */
   write_gpx_url(waypointp);
-  writer->writeOptionalTextElement("sym", waypointp->icon_descr);
+  writer->writeOptionalTextElement(QStringLiteral("sym"), waypointp->icon_descr);
   /* TODO: type should go here */
 }
 
@@ -1675,9 +1675,9 @@ gpx_waypt_pr(const Waypoint* waypointp)
   fs_xml* fs_gpx;
   garmin_fs_t* gmsd;   /* gARmIN sPECIAL dATA */
 
-  writer->writeStartElement("wpt");
-  writer->writeAttribute("lat", toString(waypointp->latitude));
-  writer->writeAttribute("lon", toString(waypointp->longitude));
+  writer->writeStartElement(QStringLiteral("wpt"));
+  writer->writeAttribute(QStringLiteral("lat"), toString(waypointp->latitude));
+  writer->writeAttribute(QStringLiteral("lon"), toString(waypointp->longitude));
 
   oname = global_opts.synthesize_shortnames ?
           mkshort_from_wpt(mkshort_handle, waypointp) :
@@ -1710,12 +1710,12 @@ gpx_track_hdr(const route_head* rte)
   fs_xml* fs_gpx;
   current_trk_head = rte;
 
-  writer->writeStartElement("trk");
-  writer->writeOptionalTextElement("name", rte->rte_name);
-  writer->writeOptionalTextElement("desc", rte->rte_desc);
+  writer->writeStartElement(QStringLiteral("trk"));
+  writer->writeOptionalTextElement(QStringLiteral("name"), rte->rte_name);
+  writer->writeOptionalTextElement(QStringLiteral("desc"), rte->rte_desc);
 
   if (rte->rte_num) {
-    writer->writeTextElement("number", QString::number(rte->rte_num));
+    writer->writeTextElement(QStringLiteral("number"), QString::number(rte->rte_num));
   }
 
   if (gpx_wversion_num > 10) {
@@ -1728,9 +1728,9 @@ gpx_track_hdr(const route_head* rte)
       if (rte->line_color.bbggrr > unknown_color) {
         int ci = gt_color_index_by_rgb(rte->line_color.bbggrr);
         if (ci > 0) {
-          writer->writeStartElement("extensions");
-          writer->writeStartElement("gpxx:TrackExtension");
-          writer->writeTextElement("gpxx:DisplayColor", QString("%1")
+          writer->writeStartElement(QStringLiteral("extensions"));
+          writer->writeStartElement(QStringLiteral("gpxx:TrackExtension"));
+          writer->writeTextElement(QStringLiteral("gpxx:DisplayColor"), QStringLiteral("%1")
                                    .arg(gt_color_name(ci)));
           writer->writeEndElement(); // Close gpxx:TrackExtension tag
           writer->writeEndElement(); // Close extensions tag
@@ -1750,12 +1750,12 @@ gpx_track_disp(const Waypoint* waypointp)
     if (!first_in_trk) {
       writer->writeEndElement();
     }
-    writer->writeStartElement("trkseg");
+    writer->writeStartElement(QStringLiteral("trkseg"));
   }
 
-  writer->writeStartElement("trkpt");
-  writer->writeAttribute("lat", toString(waypointp->latitude));
-  writer->writeAttribute("lon", toString(waypointp->longitude));
+  writer->writeStartElement(QStringLiteral("trkpt"));
+  writer->writeAttribute(QStringLiteral("lat"), toString(waypointp->latitude));
+  writer->writeAttribute(QStringLiteral("lon"), toString(waypointp->longitude));
 
   gpx_write_common_position(waypointp, gpxpt_track);
 
@@ -1805,12 +1805,12 @@ gpx_route_hdr(const route_head* rte)
 {
   fs_xml* fs_gpx;
 
-  writer->writeStartElement("rte");
-  writer->writeOptionalTextElement("name", rte->rte_name);
-  writer->writeOptionalTextElement("desc", rte->rte_desc);
+  writer->writeStartElement(QStringLiteral("rte"));
+  writer->writeOptionalTextElement(QStringLiteral("name"), rte->rte_name);
+  writer->writeOptionalTextElement(QStringLiteral("desc"), rte->rte_desc);
 
   if (rte->rte_num) {
-    writer->writeTextElement("number", QString::number(rte->rte_num));
+    writer->writeTextElement(QStringLiteral("number"), QString::number(rte->rte_num));
   }
 
   if (gpx_wversion_num > 10) {
@@ -1823,11 +1823,11 @@ gpx_route_hdr(const route_head* rte)
       if (rte->line_color.bbggrr > unknown_color) {
         int ci = gt_color_index_by_rgb(rte->line_color.bbggrr);
         if (ci > 0) {
-          writer->writeStartElement("extensions");
-          writer->writeStartElement("gpxx:RouteExtension");
+          writer->writeStartElement(QStringLiteral("extensions"));
+          writer->writeStartElement(QStringLiteral("gpxx:RouteExtension"));
           // FIXME: the value to use for IsAutoNamed is questionable.
-          writer->writeTextElement("gpxx:IsAutoNamed", rte->rte_name.isEmpty()? "true" : "false"); // Required element
-          writer->writeTextElement("gpxx:DisplayColor", QString("%1")
+          writer->writeTextElement(QStringLiteral("gpxx:IsAutoNamed"), rte->rte_name.isEmpty()? QStringLiteral("true") : QStringLiteral("false")); // Required element
+          writer->writeTextElement(QStringLiteral("gpxx:DisplayColor"), QStringLiteral("%1")
                                    .arg(gt_color_name(ci)));
           writer->writeEndElement(); // Close gpxx:RouteExtension tag
           writer->writeEndElement(); // Close extensions tag
@@ -1842,9 +1842,9 @@ gpx_route_disp(const Waypoint* waypointp)
 {
   QString oname;
   fs_xml* fs_gpx;
-  writer->writeStartElement("rtept");
-  writer->writeAttribute("lat", toString(waypointp->latitude));
-  writer->writeAttribute("lon", toString(waypointp->longitude));
+  writer->writeStartElement(QStringLiteral("rtept"));
+  writer->writeAttribute(QStringLiteral("lat"), toString(waypointp->latitude));
+  writer->writeAttribute(QStringLiteral("lon"), toString(waypointp->longitude));
 
   oname = global_opts.synthesize_shortnames ?
           mkshort_from_wpt(mkshort_handle, waypointp) :
@@ -1893,11 +1893,11 @@ gpx_write_bounds()
   track_disp_all(NULL, NULL, gpx_waypt_bound_calc);
 
   if (waypt_bounds_valid(&all_bounds)) {
-    writer->writeStartElement("bounds");
-    writer->writeAttribute("minlat", toString(all_bounds.min_lat));
-    writer->writeAttribute("minlon", toString(all_bounds.min_lon));
-    writer->writeAttribute("maxlat", toString(all_bounds.max_lat));
-    writer->writeAttribute("maxlon", toString(all_bounds.max_lon));
+    writer->writeStartElement(QStringLiteral("bounds"));
+    writer->writeAttribute(QStringLiteral("minlat"), toString(all_bounds.min_lat));
+    writer->writeAttribute(QStringLiteral("minlon"), toString(all_bounds.min_lon));
+    writer->writeAttribute(QStringLiteral("maxlat"), toString(all_bounds.max_lat));
+    writer->writeAttribute(QStringLiteral("maxlon"), toString(all_bounds.max_lon));
     writer->writeEndElement();
   }
 }

diff --git a/hiketech.cc b/hiketech.cc
index 29a3d24042bff1afcd30daa3f0cf5a8725b37db1..ee163693fc280530ded45fd84e052b031d14faf0 100644 (file)
--- a/hiketech.cc
+++ b/hiketech.cc
@@ -115,9 +115,9 @@ hiketech_wr_deinit()
 static void
 hiketech_trk_hdr(const route_head* rte)
 {
-  writer.writeStartElement("trk");
+  writer.writeStartElement(QStringLiteral("trk"));
   writer.setAutoFormattingIndent(1);
-  writer.writeOptionalTextElement("ident", rte->rte_name);
+  writer.writeOptionalTextElement(QStringLiteral("ident"), rte->rte_name);
 }
 
 static void
@@ -145,15 +145,15 @@ hiketech_format_time(const QDateTime& t)
 static void
 hiketech_trkpt_pr(const Waypoint* waypointp)
 {
-  writer.writeStartElement("pnt"); 
+  writer.writeStartElement(QStringLiteral("pnt")); 
   if (waypointp->creation_time.isValid()) {
-    writer.writeTextElement("utc", 
+    writer.writeTextElement(QStringLiteral("utc"), 
                             hiketech_format_time(waypointp->GetCreationTime()));
   }
-  writer.writeTextElement("lat", QString::number(waypointp->latitude,'f', 6));
-  writer.writeTextElement("long", QString::number(waypointp->longitude,'f', 6));
+  writer.writeTextElement(QStringLiteral("lat"), QString::number(waypointp->latitude,'f', 6));
+  writer.writeTextElement(QStringLiteral("long"), QString::number(waypointp->longitude,'f', 6));
   if (waypointp->altitude != unknown_alt) {
-    writer.writeTextElement("alt", QString::number(waypointp->altitude,'f', 6));
+    writer.writeTextElement(QStringLiteral("alt"), QString::number(waypointp->altitude,'f', 6));
   }
   writer.writeEndElement(); // png
 }
@@ -161,15 +161,15 @@ hiketech_trkpt_pr(const Waypoint* waypointp)
 static void
 hiketech_waypt_pr(const Waypoint* wpt)
 {
-  writer.writeStartElement("wpt"); 
+  writer.writeStartElement(QStringLiteral("wpt")); 
   writer.setAutoFormattingIndent(-1);
-  writer.writeTextElement("ident", wpt->shortname);
-  writer.writeTextElement("sym", wpt->icon_descr);
-  writer.writeTextElement("lat", QString::number(wpt->latitude, 'f', 6));
-  writer.writeTextElement("long", QString::number(wpt->longitude, 'f', 6));
-  writer.writeStartElement("color"); 
-  writer.writeTextElement("lbl", "FAFFB4");
-  writer.writeTextElement("obj", "FF8000");
+  writer.writeTextElement(QStringLiteral("ident"), wpt->shortname);
+  writer.writeTextElement(QStringLiteral("sym"), wpt->icon_descr);
+  writer.writeTextElement(QStringLiteral("lat"), QString::number(wpt->latitude, 'f', 6));
+  writer.writeTextElement(QStringLiteral("long"), QString::number(wpt->longitude, 'f', 6));
+  writer.writeStartElement(QStringLiteral("color")); 
+  writer.writeTextElement(QStringLiteral("lbl"), QStringLiteral("FAFFB4"));
+  writer.writeTextElement(QStringLiteral("obj"), QStringLiteral("FF8000"));
   writer.writeEndElement(); // color
 
   writer.writeEndElement(); // wpt
@@ -178,11 +178,11 @@ hiketech_waypt_pr(const Waypoint* wpt)
 static void
 hiketech_write()
 {
-  writer.writeStartElement("hiketech");
-  writer.writeAttribute("version", "1.2");
-  writer.writeAttribute("url", "http://www.hiketech.com");
+  writer.writeStartElement(QStringLiteral("hiketech"));
+  writer.writeAttribute(QStringLiteral("version"), QStringLiteral("1.2"));
+  writer.writeAttribute(QStringLiteral("url"), QStringLiteral("http://www.hiketech.com"));
   writer.setAutoFormatting(true);
-  writer.writeStartElement("gpsdata");
+  writer.writeStartElement(QStringLiteral("gpsdata"));
   track_disp_all(hiketech_trk_hdr, hiketech_trk_tlr, hiketech_trkpt_pr);
   track_disp_all(NULL, NULL, hiketech_trkpt_pr);
   waypt_disp_all(hiketech_waypt_pr);

diff --git a/kml.cc b/kml.cc
index fce7a982f3eba9063fdb7604b659cde85a218ba1..c591bcd89bef0c183e3322ec08e4013791614da8 100644 (file)
--- a/kml.cc
+++ b/kml.cc
@@ -608,44 +608,43 @@ void
 kml_output_linestyle(char* /*color*/, int width)
 {
   // Style settings for line strings
-  writer->writeStartElement("LineStyle");
-  writer->writeTextElement("color", opt_line_color);
-  writer->writeTextElement("width", QString::number(width));
+  writer->writeStartElement(QStringLiteral("LineStyle"));
+  writer->writeTextElement(QStringLiteral("color"), opt_line_color);
+  writer->writeTextElement(QStringLiteral("width"), QString::number(width));
   writer->writeEndElement(); // Close LineStyle tag
 }
 
 
-#define hovertag(h) h ? 'h' : 'n'
 static void kml_write_bitmap_style_(const QString& style, const QString& bitmap,
                                     int highlighted, int force_heading)
 {
   int is_track = style.startsWith("track");
   int is_multitrack = style.startsWith("multiTrack");
 
-  writer->writeComment(QString(" ") + QString(highlighted ? "Highlighted" : "Normal") + QString(" ") + style + QString(" style "));
-  writer->writeStartElement("Style");
-  writer->writeAttribute("id", style + QString("_") + QString(hovertag(highlighted)));
+  writer->writeComment((highlighted ? QStringLiteral(" Highlighted ") : QStringLiteral(" Normal ")) + style + QStringLiteral(" style "));
+  writer->writeStartElement(QStringLiteral("Style"));
+  writer->writeAttribute(QStringLiteral("id"), style + (highlighted? QStringLiteral("_h") : QStringLiteral("_n")));
 
-  writer->writeStartElement("IconStyle");
+  writer->writeStartElement(QStringLiteral("IconStyle"));
   if (highlighted) {
-    writer->writeTextElement("scale", "1.2");
+    writer->writeTextElement(QStringLiteral("scale"), QStringLiteral("1.2"));
   } else {
     if (is_track) {
-      writer->writeTextElement("scale", ".5");
+      writer->writeTextElement(QStringLiteral("scale"), QStringLiteral(".5"));
     }
   }
   /* Our icons are pre-rotated, so nail them to the maps. */
   if (force_heading) {
-    writer->writeTextElement("heading", "0");
+    writer->writeTextElement(QStringLiteral("heading"), QStringLiteral("0"));
   }
-  writer->writeStartElement("Icon");
-  writer->writeTextElement("href", bitmap);
+  writer->writeStartElement(QStringLiteral("Icon"));
+  writer->writeTextElement(QStringLiteral("href"), bitmap);
   writer->writeEndElement(); // Close Icon tag
   writer->writeEndElement(); // Close IconStyle tag
 
   if (is_track && !highlighted) {
-    writer->writeStartElement("LabelStyle");
-    writer->writeTextElement("scale", "0");
+    writer->writeStartElement(QStringLiteral("LabelStyle"));
+    writer->writeTextElement(QStringLiteral("scale"), QStringLiteral("0"));
     writer->writeEndElement(); //Close LabelStyle tag
   }
 
@@ -692,15 +691,15 @@ static void kml_write_bitmap_style(kml_point_type pt_type, const QString& bitmap
   kml_write_bitmap_style_(style, bitmap, 0, force_heading);
   kml_write_bitmap_style_(style, bitmap, 1, force_heading);
 
-  writer->writeStartElement("StyleMap");
-  writer->writeAttribute("id", style);
-  writer->writeStartElement("Pair");
-  writer->writeTextElement("key", "normal");
-  writer->writeTextElement("styleUrl", QString("#") + style + QString("_") + QString(hovertag(0)));
+  writer->writeStartElement(QStringLiteral("StyleMap"));
+  writer->writeAttribute(QStringLiteral("id"), style);
+  writer->writeStartElement(QStringLiteral("Pair"));
+  writer->writeTextElement(QStringLiteral("key"), QStringLiteral("normal"));
+  writer->writeTextElement(QStringLiteral("styleUrl"), QStringLiteral("#") + style + QStringLiteral("_n"));
   writer->writeEndElement(); // Close Pair tag
-  writer->writeStartElement("Pair");
-  writer->writeTextElement("key", "highlight");
-  writer->writeTextElement("styleUrl", QString("#") + style + QString("_") + QString(hovertag(1)));
+  writer->writeStartElement(QStringLiteral("Pair"));
+  writer->writeTextElement(QStringLiteral("key"), QStringLiteral("highlight"));
+  writer->writeTextElement(QStringLiteral("styleUrl"), QStringLiteral("#") + style + QStringLiteral("_h"));
   writer->writeEndElement(); // Close Pair tag
   writer->writeEndElement(); // Close StyleMap tag
 }
@@ -709,8 +708,8 @@ static void kml_output_timestamp(const Waypoint* waypointp)
 {
   QString time_string = waypointp->CreationTimeXML();
   if (!time_string.isEmpty()) {
-    writer->writeStartElement("TimeStamp");
-    writer->writeTextElement("when", time_string);
+    writer->writeStartElement(QStringLiteral("TimeStamp"));
+    writer->writeTextElement(QStringLiteral("when"), time_string);
     writer->writeEndElement(); // Close TimeStamp tag
   }
 }
@@ -718,10 +717,10 @@ static void kml_output_timestamp(const Waypoint* waypointp)
 static
 void kml_td(gpsbabel::XmlStreamWriter& hwriter, const QString& boldData, const QString& data)
 {
-  hwriter.writeCharacters("\n");
-  hwriter.writeStartElement("tr");
-  hwriter.writeStartElement("td");
-  hwriter.writeTextElement("b", boldData);
+  hwriter.writeCharacters(QStringLiteral("\n"));
+  hwriter.writeStartElement(QStringLiteral("tr"));
+  hwriter.writeStartElement(QStringLiteral("td"));
+  hwriter.writeTextElement(QStringLiteral("b"), boldData);
   hwriter.writeCharacters(data);
   hwriter.writeEndElement(); // Close td tag
   hwriter.writeEndElement(); // Close tr tag
@@ -730,9 +729,9 @@ void kml_td(gpsbabel::XmlStreamWriter& hwriter, const QString& boldData, const Q
 static
 void kml_td(gpsbabel::XmlStreamWriter& hwriter, const QString& data)
 {
-  hwriter.writeCharacters("\n");
-  hwriter.writeStartElement("tr");
-  hwriter.writeStartElement("td");
+  hwriter.writeCharacters(QStringLiteral("\n"));
+  hwriter.writeStartElement(QStringLiteral("tr"));
+  hwriter.writeStartElement(QStringLiteral("td"));
   hwriter.writeCharacters(data);
   hwriter.writeEndElement(); // Close td tag
   hwriter.writeEndElement(); // Close tr tag
@@ -762,83 +761,83 @@ void kml_output_trkdescription(const route_head* header, computed_trkdata* td)
   min_alt = fmt_altitude(td->min_alt, &min_alt_units);
   distance = fmt_distance(td->distance_meters, &distance_units);
 
-  writer->writeEmptyElement("snippet");
+  writer->writeEmptyElement(QStringLiteral("snippet"));
 
-  writer->writeStartElement("description");
+  writer->writeStartElement(QStringLiteral("description"));
 
-  hwriter.writeStartElement("table");
+  hwriter.writeStartElement(QStringLiteral("table"));
   if (!header->rte_desc.isEmpty()) {
-    kml_td(hwriter, "Description", QString(" %1 ").arg(header->rte_desc));
+    kml_td(hwriter, QStringLiteral("Description"), QStringLiteral(" %1 ").arg(header->rte_desc));
   }
-  kml_td(hwriter, "Distance", QString(" %1 %2 ").arg(QString::number(distance, 'f', 1)).arg(distance_units));
+  kml_td(hwriter, QStringLiteral("Distance"), QStringLiteral(" %1 %2 ").arg(QString::number(distance, 'f', 1)).arg(distance_units));
   if (td->min_alt != -unknown_alt) {
-    kml_td(hwriter, "Min Alt", QString(" %1 %2 ").arg(QString::number(min_alt, 'f', 3)).arg(min_alt_units));
+    kml_td(hwriter, QStringLiteral("Min Alt"), QStringLiteral(" %1 %2 ").arg(QString::number(min_alt, 'f', 3)).arg(min_alt_units));
   }
   if (td->max_alt != unknown_alt) {
-    kml_td(hwriter, "Max Alt", QString(" %1 %2 ").arg(QString::number(max_alt, 'f', 3)).arg(max_alt_units));
+    kml_td(hwriter, QStringLiteral("Max Alt"), QStringLiteral(" %1 %2 ").arg(QString::number(max_alt, 'f', 3)).arg(max_alt_units));
   }
   if (td->min_spd) {
     const char* spd_units;
     double spd = fmt_speed(td->min_spd, &spd_units);
-    kml_td(hwriter, "Min Speed", QString(" %1 %2 ").arg(QString::number(spd, 'f', 1)).arg(spd_units));
+    kml_td(hwriter, QStringLiteral("Min Speed"), QStringLiteral(" %1 %2 ").arg(QString::number(spd, 'f', 1)).arg(spd_units));
   }
   if (td->max_spd) {
     const char* spd_units;
     double spd = fmt_speed(td->max_spd, &spd_units);
-    kml_td(hwriter, "Max Speed", QString(" %1 %2 ").arg(QString::number(spd, 'f', 1)).arg(spd_units));
+    kml_td(hwriter, QStringLiteral("Max Speed"), QStringLiteral(" %1 %2 ").arg(QString::number(spd, 'f', 1)).arg(spd_units));
   }
   if (td->max_spd && td->start && td->end) {
     const char* spd_units;
     time_t elapsed = td->end - td->start;
     double spd = fmt_speed(td->distance_meters / elapsed, &spd_units);
     if (spd > 1.0)  {
-      kml_td(hwriter, "Avg Speed", QString(" %1 %2 ").arg(QString::number(spd, 'f', 1)).arg(spd_units));
+      kml_td(hwriter, QStringLiteral("Avg Speed"), QStringLiteral(" %1 %2 ").arg(QString::number(spd, 'f', 1)).arg(spd_units));
     }
   }
   if (td->avg_hrt) {
-    kml_td(hwriter, "Avg Heart Rate", QString(" %1 bpm ").arg(QString::number(td->avg_hrt, 'f', 1)));
+    kml_td(hwriter, QStringLiteral("Avg Heart Rate"), QStringLiteral(" %1 bpm ").arg(QString::number(td->avg_hrt, 'f', 1)));
   }
   if (td->min_hrt < td->max_hrt) {
-    kml_td(hwriter, "Min Heart Rate", QString(" %1 bpm ").arg(QString::number(td->min_hrt)));
+    kml_td(hwriter, QStringLiteral("Min Heart Rate"), QStringLiteral(" %1 bpm ").arg(QString::number(td->min_hrt)));
   }
   if (td->max_hrt) {
-    kml_td(hwriter, "Max Heart Rate", QString(" %1 bpm ").arg(QString::number(td->max_hrt)));
+    kml_td(hwriter, QStringLiteral("Max Heart Rate"), QStringLiteral(" %1 bpm ").arg(QString::number(td->max_hrt)));
   }
   if (td->avg_cad) {
-    kml_td(hwriter, "Avg Cadence", QString(" %1 rpm ").arg(QString::number(td->avg_cad, 'f', 1)));
+    kml_td(hwriter, QStringLiteral("Avg Cadence"), QStringLiteral(" %1 rpm ").arg(QString::number(td->avg_cad, 'f', 1)));
   }
   if (td->max_cad) {
-    kml_td(hwriter, "Max Cadence", QString(" %1 rpm ").arg(QString::number(td->max_cad)));
+    kml_td(hwriter, QStringLiteral("Max Cadence"), QStringLiteral(" %1 rpm ").arg(QString::number(td->max_cad)));
   }
   if (td->start && td->end) {
     gpsbabel::DateTime t;
     t = QDateTime::fromTime_t(td->start);
     if (t.isValid()) {
-      kml_td(hwriter, "Start Time", t.toPrettyString());
+      kml_td(hwriter, QStringLiteral("Start Time"), t.toPrettyString());
     }
     t = QDateTime::fromTime_t(td->end);
     if (t.isValid()) {
-      kml_td(hwriter, "End Time", t.toPrettyString());
+      kml_td(hwriter, QStringLiteral("End Time"), t.toPrettyString());
     }
   }
 
-  hwriter.writeCharacters("\n");
+  hwriter.writeCharacters(QStringLiteral("\n"));
   hwriter.writeEndElement(); // Close table tag
   //hwriter.writeEndDocument(); // FIXME: it seems like we should end the doc but it causes a reference mismatch by adding a final \n
-  writer->writeCharacters("\n");
+  writer->writeCharacters(QStringLiteral("\n"));
   writer->writeCDATA(hstring);
-  writer->writeCharacters("\n");
+  writer->writeCharacters(QStringLiteral("\n"));
   writer->writeEndElement(); // Close description tag
 
   /* We won't always have times. Garmin saved tracks, for example... */
   if (td->start && td->end) {
-    writer->writeStartElement("TimeSpan");
+    writer->writeStartElement(QStringLiteral("TimeSpan"));
 
     gpsbabel::DateTime t;
     t = QDateTime::fromTime_t(td->start);
-    writer->writeTextElement("begin", t.toPrettyString());
+    writer->writeTextElement(QStringLiteral("begin"), t.toPrettyString());
     t = QDateTime::fromTime_t(td->end);
-    writer->writeTextElement("end", t.toPrettyString());
+    writer->writeTextElement(QStringLiteral("end"), t.toPrettyString());
 
     writer->writeEndElement(); // Close TimeSpan tag
   }
@@ -849,15 +848,15 @@ static
 void kml_output_header(const route_head* header, computed_trkdata* td)
 {
   if (!realtime_positioning)  {
-    writer->writeStartElement("Folder");
+    writer->writeStartElement(QStringLiteral("Folder"));
   }
-  writer->writeOptionalTextElement("name", header->rte_name);
+  writer->writeOptionalTextElement(QStringLiteral("name"), header->rte_name);
   kml_output_trkdescription(header, td);
 
   if (export_points && header->rte_waypt_ct > 0) {
     // Put the points in a subfolder
-    writer->writeStartElement("Folder");
-    writer->writeTextElement("name", "Points");
+    writer->writeStartElement(QStringLiteral("Folder"));
+    writer->writeTextElement(QStringLiteral("name"), QStringLiteral("Points"));
   }
 }
 
@@ -879,13 +878,13 @@ static
 void kml_write_coordinates(const Waypoint* waypointp)
 {
   if (kml_altitude_known(waypointp)) {
-    writer->writeTextElement("coordinates",
+    writer->writeTextElement(QStringLiteral("coordinates"),
                              QString::number(waypointp->longitude, 'f', precision) + QString(",") +
                              QString::number(waypointp->latitude, 'f', precision) + QString(",") +
                              QString::number(waypointp->altitude, 'f', 2)
                             );
   } else {
-    writer->writeTextElement("coordinates",
+    writer->writeTextElement(QStringLiteral("coordinates"),
                              QString::number(waypointp->longitude, 'f', precision) + QString(",") +
                              QString::number(waypointp->latitude, 'f', precision)
                             );
@@ -897,10 +896,10 @@ void kml_write_coordinates(const Waypoint* waypointp)
  */
 static void kml_output_lookat(const Waypoint* waypointp)
 {
-  writer->writeStartElement("LookAt");
-  writer->writeTextElement("longitude", QString::number(waypointp->longitude, 'f', precision));
-  writer->writeTextElement("latitude", QString::number(waypointp->latitude, 'f', precision));
-  writer->writeTextElement("tilt","66");
+  writer->writeStartElement(QStringLiteral("LookAt"));
+  writer->writeTextElement(QStringLiteral("longitude"), QString::number(waypointp->longitude, 'f', precision));
+  writer->writeTextElement(QStringLiteral("latitude"), QString::number(waypointp->latitude, 'f', precision));
+  writer->writeTextElement(QStringLiteral("tilt"), QStringLiteral("66"));
   writer->writeEndElement(); // Close LookAt tag
 }
 
@@ -908,15 +907,15 @@ static void kml_output_positioning(bool tessellate)
 {
   // These elements must be output as a sequence, i.e. in order.
   if (extrude) {
-    writer->writeTextElement("extrude", "1");
+    writer->writeTextElement(QStringLiteral("extrude"), QStringLiteral("1"));
   }
 
   if (tessellate) {
-    writer->writeTextElement("tessellate", "1");
+    writer->writeTextElement(QStringLiteral("tessellate"), QStringLiteral("1"));
   }
 
   if (floating) {
-    writer->writeTextElement("altitudeMode", "absolute");
+    writer->writeTextElement(QStringLiteral("altitudeMode"), QStringLiteral("absolute"));
   }
 
 }
@@ -936,44 +935,44 @@ static void kml_output_description(const Waypoint* pt)
 
   alt = fmt_altitude(pt->altitude, &alt_units);
 
-  writer->writeStartElement("description");
-  hwriter.writeCharacters("\n");
-  hwriter.writeStartElement("table");
+  writer->writeStartElement(QStringLiteral("description"));
+  hwriter.writeCharacters(QStringLiteral("\n"));
+  hwriter.writeStartElement(QStringLiteral("table"));
 
-  kml_td(hwriter, QString("Longitude: %1 ").arg(QString::number(pt->longitude, 'f', precision)));
-  kml_td(hwriter, QString("Latitude: %1 ").arg(QString::number(pt->latitude, 'f', precision)));
+  kml_td(hwriter, QStringLiteral("Longitude: %1 ").arg(QString::number(pt->longitude, 'f', precision)));
+  kml_td(hwriter, QStringLiteral("Latitude: %1 ").arg(QString::number(pt->latitude, 'f', precision)));
 
   if (kml_altitude_known(pt)) {
-    kml_td(hwriter, QString("Altitude: %1 %2 ").arg(QString::number(alt, 'f', 3)).arg(alt_units));
+    kml_td(hwriter, QStringLiteral("Altitude: %1 %2 ").arg(QString::number(alt, 'f', 3)).arg(alt_units));
   }
 
   if (pt->heartrate) {
-    kml_td(hwriter, QString("Heart rate: %1 ").arg(QString::number(pt->heartrate)));
+    kml_td(hwriter, QStringLiteral("Heart rate: %1 ").arg(QString::number(pt->heartrate)));
   }
 
   if (pt->cadence) {
-    kml_td(hwriter, QString("Cadence: %1 ").arg(QString::number(pt->cadence)));
+    kml_td(hwriter, QStringLiteral("Cadence: %1 ").arg(QString::number(pt->cadence)));
   }
 
   /* Which unit is this temp in? C? F? K? */
   if WAYPT_HAS(pt, temperature) {
-    kml_td(hwriter, QString("Temperature: %1 ").arg(QString::number(pt->temperature, 'f', 1)));
+    kml_td(hwriter, QStringLiteral("Temperature: %1 ").arg(QString::number(pt->temperature, 'f', 1)));
   }
 
   if WAYPT_HAS(pt, depth) {
     const char* depth_units;
     double depth = fmt_distance(pt->depth, &depth_units);
-    kml_td(hwriter, QString("Depth: %1 %2 ").arg(QString::number(depth, 'f', 1)).arg(depth_units));
+    kml_td(hwriter, QStringLiteral("Depth: %1 %2 ").arg(QString::number(depth, 'f', 1)).arg(depth_units));
   }
 
   if WAYPT_HAS(pt, speed) {
     const char* spd_units;
     double spd = fmt_speed(pt->speed, &spd_units);
-    kml_td(hwriter, QString("Speed: %1 %2 ").arg(QString::number(spd, 'f', 1)).arg(spd_units));
+    kml_td(hwriter, QStringLiteral("Speed: %1 %2 ").arg(QString::number(spd, 'f', 1)).arg(spd_units));
   }
 
   if WAYPT_HAS(pt, course) {
-    kml_td(hwriter, QString("Heading: %1 ").arg(QString::number(pt->course, 'f', 1)));
+    kml_td(hwriter, QStringLiteral("Heading: %1 ").arg(QString::number(pt->course, 'f', 1)));
   }
 
   /* This really shouldn't be here, but as of this writing,
@@ -982,11 +981,11 @@ static void kml_output_description(const Waypoint* pt)
   if (pt->GetCreationTime().isValid()) {
     QString time_string = pt->CreationTimeXML();
     if (!time_string.isEmpty()) {
-      kml_td(hwriter, QString("Time: %1 ").arg(time_string));
+      kml_td(hwriter, QStringLiteral("Time: %1 ").arg(time_string));
     }
   }
 
-  hwriter.writeCharacters("\n");
+  hwriter.writeCharacters(QStringLiteral("\n"));
   hwriter.writeEndElement(); // Close table tag
   hwriter.writeEndDocument();
   writer->writeCDATA(hstring);
@@ -1030,21 +1029,21 @@ static void kml_output_point(const Waypoint* waypointp, kml_point_type pt_type)
   }
 
   if (export_points) {
-    writer->writeStartElement("Placemark");
+    writer->writeStartElement(QStringLiteral("Placemark"));
     if (atoi(opt_labels)) {
-      writer->writeOptionalTextElement("name", waypointp->shortname);
+      writer->writeOptionalTextElement(QStringLiteral("name"), waypointp->shortname);
     }
-    writer->writeEmptyElement("snippet");
+    writer->writeEmptyElement(QStringLiteral("snippet"));
     kml_output_description(waypointp);
     kml_output_lookat(waypointp);
     kml_output_timestamp(waypointp);
 
 
     if (opt_deficon) {
-      writer->writeStartElement("Style");
-      writer->writeStartElement("IconStyle");
-      writer->writeStartElement("Icon");
-      writer->writeTextElement("href", opt_deficon);
+      writer->writeStartElement(QStringLiteral("Style"));
+      writer->writeStartElement(QStringLiteral("IconStyle"));
+      writer->writeStartElement(QStringLiteral("Icon"));
+      writer->writeTextElement(QStringLiteral("href"), opt_deficon);
       writer->writeEndElement(); // Close Icon tag
       writer->writeEndElement(); // Close IconStyle tag
       writer->writeEndElement(); // Close Style tag
@@ -1057,13 +1056,13 @@ static void kml_output_point(const Waypoint* waypointp, kml_point_type pt_type)
           value = QString("%1-%2").arg(style)
                   .arg((int)(waypointp->course / 22.5 + .5) % 16);
         }
-        writer->writeTextElement("styleUrl", value);
+        writer->writeTextElement(QStringLiteral("styleUrl"), value);
       } else {
-        writer->writeTextElement("styleUrl", style);
+        writer->writeTextElement(QStringLiteral("styleUrl"), style);
       }
     }
 
-    writer->writeStartElement("Point");
+    writer->writeStartElement(QStringLiteral("Point"));
     kml_output_positioning(false);
     kml_write_coordinates(waypointp);
     writer->writeEndElement(); // Close Point tag
@@ -1092,33 +1091,33 @@ static void kml_output_tailer(const route_head* header)
         break;
       }
     }
-    writer->writeStartElement("Placemark");
-    writer->writeTextElement("name", "Path");
+    writer->writeStartElement(QStringLiteral("Placemark"));
+    writer->writeTextElement(QStringLiteral("name"), QStringLiteral("Path"));
     if (!rotate_colors) {
-      writer->writeTextElement("styleUrl", "#lineStyle");
+      writer->writeTextElement(QStringLiteral("styleUrl"), QStringLiteral("#lineStyle"));
     }
     if (header->line_color.bbggrr >= 0 || header->line_width >= 0 || rotate_colors) {
-      writer->writeStartElement("Style");
-      writer->writeStartElement("LineStyle");
+      writer->writeStartElement(QStringLiteral("Style"));
+      writer->writeStartElement(QStringLiteral("LineStyle"));
       if (rotate_colors) {
         kml_step_color();
-        writer->writeTextElement("color", QString("%1%2")
+        writer->writeTextElement(QStringLiteral("color"), QStringLiteral("%1%2")
                                  .arg(kml_color_sequencer.color.opacity, 2, 16, QChar('0')).arg(kml_color_sequencer.color.bbggrr, 6, 16, QChar('0')));
-        writer->writeTextElement("width", opt_line_width);
+        writer->writeTextElement(QStringLiteral("width"), opt_line_width);
       } else {
         if (header->line_color.bbggrr >= 0) {
-          writer->writeTextElement("color", QString("%1%2")
+          writer->writeTextElement(QStringLiteral("color"), QStringLiteral("%1%2")
                                    .arg(header->line_color.opacity, 2, 16, QChar('0')).arg(header->line_color.bbggrr, 6, 16, QChar('0')));
         }
         if (header->line_width >= 0) {
-          writer->writeTextElement("width", QString::number(header->line_width));
+          writer->writeTextElement(QStringLiteral("width"), QString::number(header->line_width));
         }
       }
       writer->writeEndElement(); // Close LineStyle tag
       writer->writeEndElement(); // Close Style tag
     }
     if (needs_multigeometry) {
-      writer->writeStartElement("MultiGeometry");
+      writer->writeStartElement(QStringLiteral("MultiGeometry"));
     }
 
     QUEUE_FOR_EACH(&header->waypoint_list, elem, tmp) {
@@ -1129,19 +1128,19 @@ static void kml_output_tailer(const route_head* header)
           writer->writeEndElement(); // Close coordinates tag
           writer->writeEndElement(); // Close LineString tag
         }
-        writer->writeStartElement("LineString");
+        writer->writeStartElement(QStringLiteral("LineString"));
         kml_output_positioning(true);
-        writer->writeStartElement("coordinates");
-        writer->writeCharacters("\n");
+        writer->writeStartElement(QStringLiteral("coordinates"));
+        writer->writeCharacters(QStringLiteral("\n"));
       }
       if (kml_altitude_known(tpt)) {
-        writer->writeCharacters(QString::number(tpt->longitude, 'f', precision) + QString(",") +
-                                QString::number(tpt->latitude, 'f', precision) + QString(",") +
-                                QString::number(tpt->altitude, 'f', 2) + QString("\n")
+        writer->writeCharacters(QString::number(tpt->longitude, 'f', precision) + QStringLiteral(",") +
+                                QString::number(tpt->latitude, 'f', precision) + QStringLiteral(",") +
+                                QString::number(tpt->altitude, 'f', 2) + QStringLiteral("\n")
                                );
       } else {
-        writer->writeCharacters(QString::number(tpt->longitude, 'f', precision) + QString(",") +
-                                QString::number(tpt->latitude, 'f', precision) + QString("\n")
+        writer->writeCharacters(QString::number(tpt->longitude, 'f', precision) + QStringLiteral(",") +
+                                QString::number(tpt->latitude, 'f', precision) + QStringLiteral("\n")
                                );
       }
     }
@@ -1194,8 +1193,8 @@ void kml_gc_make_balloonstyletext()
 {
   QString cdataStr;
 
-  writer->writeStartElement("BalloonStyle");
-  writer->writeStartElement("text");
+  writer->writeStartElement(QStringLiteral("BalloonStyle"));
+  writer->writeStartElement(QStringLiteral("text"));
   cdataStr.append("\n");
 
   cdataStr.append("<!DOCTYPE html>\n");
@@ -1271,39 +1270,39 @@ void kml_gc_make_balloonstyle()
   // It's unfortunate that we have to repeat so much of the template
   // but KML doesn't have a cascading style-like substance.
   //
-  writer->writeStartElement("Style");
-  writer->writeAttribute("id", "geocache_n");
-  writer->writeStartElement("IconStyle");
-  writer->writeTextElement("scale", ".6");
+  writer->writeStartElement(QStringLiteral("Style"));
+  writer->writeAttribute(QStringLiteral("id"), QStringLiteral("geocache_n"));
+  writer->writeStartElement(QStringLiteral("IconStyle"));
+  writer->writeTextElement(QStringLiteral("scale"), QStringLiteral(".6"));
   writer->writeEndElement(); // Close IconStyle tag
-  writer->writeStartElement("LabelStyle");
-  writer->writeTextElement("scale", "0");
+  writer->writeStartElement(QStringLiteral("LabelStyle"));
+  writer->writeTextElement(QStringLiteral("scale"), QStringLiteral("0"));
   writer->writeEndElement(); // Close LabelStyle tag
   kml_gc_make_balloonstyletext();
   writer->writeEndElement(); // Close Style tag
 
-  writer->writeStartElement("Style");
-  writer->writeAttribute("id", "geocache_h");
-  writer->writeStartElement("IconStyle");
-  writer->writeTextElement("scale", ".8");
+  writer->writeStartElement(QStringLiteral("Style"));
+  writer->writeAttribute(QStringLiteral("id"), QStringLiteral("geocache_h"));
+  writer->writeStartElement(QStringLiteral("IconStyle"));
+  writer->writeTextElement(QStringLiteral("scale"), QStringLiteral(".8"));
   writer->writeEndElement(); // Close IconStyle tag
-  writer->writeStartElement("LabelStyle");
-  writer->writeTextElement("scale", "1");
+  writer->writeStartElement(QStringLiteral("LabelStyle"));
+  writer->writeTextElement(QStringLiteral("scale"), QStringLiteral("1"));
   writer->writeEndElement(); // Close LabelStyle tag
   kml_gc_make_balloonstyletext();
   writer->writeEndElement(); // Close Style tag
 
-  writer->writeStartElement("StyleMap");
-  writer->writeAttribute("id", "geocache");
+  writer->writeStartElement(QStringLiteral("StyleMap"));
+  writer->writeAttribute(QStringLiteral("id"), QStringLiteral("geocache"));
 
-  writer->writeStartElement("Pair");
-  writer->writeTextElement("key", "normal");
-  writer->writeTextElement("styleUrl", "#geocache_n");
+  writer->writeStartElement(QStringLiteral("Pair"));
+  writer->writeTextElement(QStringLiteral("key"), QStringLiteral("normal"));
+  writer->writeTextElement(QStringLiteral("styleUrl"), QStringLiteral("#geocache_n"));
   writer->writeEndElement(); // Close Pair tag
 
-  writer->writeStartElement("Pair");
-  writer->writeTextElement("key", "highlight");
-  writer->writeTextElement("styleUrl", "#geocache_h");
+  writer->writeStartElement(QStringLiteral("Pair"));
+  writer->writeTextElement(QStringLiteral("key"), QStringLiteral("highlight"));
+  writer->writeTextElement(QStringLiteral("styleUrl"), QStringLiteral("#geocache_h"));
   writer->writeEndElement(); // Close Pair tag
 
   writer->writeEndElement(); // Close StyleMap tag
@@ -1481,33 +1480,33 @@ static QString kml_geocache_get_logs(const Waypoint* wpt)
 
 static void kml_write_data_element(const QString& name, const QString& value)
 {
-  writer->writeStartElement("Data");
-  writer->writeAttribute("name", name);
-  writer->writeTextElement("value", value);
+  writer->writeStartElement(QStringLiteral("Data"));
+  writer->writeAttribute(QStringLiteral("name"), name);
+  writer->writeTextElement(QStringLiteral("value"), value);
   writer->writeEndElement(); // Close Data tag
 }
 
 static void kml_write_data_element(const QString& name, const int value)
 {
-  writer->writeStartElement("Data");
-  writer->writeAttribute("name", name);
-  writer->writeTextElement("value", QString::number(value));
+  writer->writeStartElement(QStringLiteral("Data"));
+  writer->writeAttribute(QStringLiteral("name"), name);
+  writer->writeTextElement(QStringLiteral("value"), QString::number(value));
   writer->writeEndElement(); // Close Data tag
 }
 
 static void kml_write_data_element(const QString& name, const double value)
 {
-  writer->writeStartElement("Data");
-  writer->writeAttribute("name", name);
-  writer->writeTextElement("value", QString::number(value, 'f', 6));
+  writer->writeStartElement(QStringLiteral("Data"));
+  writer->writeAttribute(QStringLiteral("name"), name);
+  writer->writeTextElement(QStringLiteral("value"), QString::number(value, 'f', 6));
   writer->writeEndElement(); // Close Data tag
 }
 
 static void kml_write_cdata_element(const QString& name, const QString& value)
 {
-  writer->writeStartElement("Data");
-  writer->writeAttribute("name", name);
-  writer->writeStartElement("value");
+  writer->writeStartElement(QStringLiteral("Data"));
+  writer->writeAttribute(QStringLiteral("name"), name);
+  writer->writeStartElement(QStringLiteral("value"));
   writer->writeCDATA(value);
   writer->writeEndElement(); // Close value tag
   writer->writeEndElement(); // Close Data tag
@@ -1517,9 +1516,9 @@ static void kml_geocache_pr(const Waypoint* waypointp)
 {
   const char* issues = "";
 
-  writer->writeStartElement("Placemark");
+  writer->writeStartElement(QStringLiteral("Placemark"));
 
-  writer->writeStartElement("name");
+  writer->writeStartElement(QStringLiteral("name"));
   if (waypointp->HasUrlLink()) {
     UrlLink link = waypointp->GetUrlLink();
     writer->writeCDATA(link.url_link_text_);
@@ -1533,17 +1532,17 @@ static void kml_geocache_pr(const Waypoint* waypointp)
     date_placed = waypointp->GetCreationTime().toString("dd-MMM-yyyy");
   }
 
-  writer->writeTextElement("styleUrl", "#geocache");
-  writer->writeStartElement("Style");
-  writer->writeStartElement("IconStyle");
-  writer->writeStartElement("Icon");
+  writer->writeTextElement(QStringLiteral("styleUrl"), QStringLiteral("#geocache"));
+  writer->writeStartElement(QStringLiteral("Style"));
+  writer->writeStartElement(QStringLiteral("IconStyle"));
+  writer->writeStartElement(QStringLiteral("Icon"));
   QString is = kml_lookup_gc_icon(waypointp);
-  writer->writeTextElement("href", is);
+  writer->writeTextElement(QStringLiteral("href"), is);
   writer->writeEndElement(); // Close Icon tag
   writer->writeEndElement(); // Close IconStyle tag
   writer->writeEndElement(); // Close Style tag
 
-  writer->writeStartElement("ExtendedData");
+  writer->writeStartElement(QStringLiteral("ExtendedData"));
   if (!waypointp->shortname.isEmpty()) {
     kml_write_data_element("gc_num", waypointp->shortname);
   }
@@ -1587,7 +1586,7 @@ static void kml_geocache_pr(const Waypoint* waypointp)
   writer->writeEndElement(); // Close ExtendedData tag
 
   // Location
-  writer->writeStartElement("Point");
+  writer->writeStartElement(QStringLiteral("Point"));
   kml_write_coordinates(waypointp);
 
   writer->writeEndElement(); // Close Point tag
@@ -1605,9 +1604,9 @@ static void kml_waypt_pr(const Waypoint* waypointp)
 #if 0 // Experimental
   if (realtime_positioning) {
     writer->wrteStartTag("LookAt");
-    writer->writeTextElement("longitude", QString::number(waypointp->longitude, 'f', precision);
-                             writer->writeTextElement("latitude", QString::number(waypointp->latitude, 'f', precision);
-                                 writer->writeTextElement("altitude", "1000");
+    writer->writeTextElement(QStringLiteral("longitude"), QString::number(waypointp->longitude, 'f', precision);
+                             writer->writeTextElement(QStringLiteral("latitude"), QString::number(waypointp->latitude, 'f', precision);
+                                 writer->writeTextElement(QStringLiteral("altitude"), QStringLiteral("1000"));
                                  writer->writeEndElement(); // Close LookAt tag
   }
 #endif
@@ -1617,26 +1616,26 @@ static void kml_waypt_pr(const Waypoint* waypointp)
     return;
   }
 
-  writer->writeStartElement("Placemark");
+  writer->writeStartElement(QStringLiteral("Placemark"));
 
-  writer->writeOptionalTextElement("name", waypointp->shortname);
+  writer->writeOptionalTextElement(QStringLiteral("name"), waypointp->shortname);
 
   // Description
   if (waypointp->HasUrlLink()) {
-    writer->writeEmptyElement("snippet");
+    writer->writeEmptyElement(QStringLiteral("snippet"));
     UrlLink link = waypointp->GetUrlLink();
     if (!link.url_link_text_.isEmpty()) {
       QString odesc = link.url_;
       QString olink = link.url_link_text_;
-      writer->writeStartElement("description");
-      writer->writeCDATA(QString("<a href=\"%1\">%2</a>").arg(odesc, olink));
+      writer->writeStartElement(QStringLiteral("description"));
+      writer->writeCDATA(QStringLiteral("<a href=\"%1\">%2</a>").arg(odesc, olink));
       writer->writeEndElement(); // Close description tag
     } else {
-      writer->writeTextElement("description", link.url_);
+      writer->writeTextElement(QStringLiteral("description"), link.url_);
     }
   } else {
     if (waypointp->shortname != waypointp->description) {
-      writer->writeOptionalTextElement("description", waypointp->description);
+      writer->writeOptionalTextElement(QStringLiteral("description"), waypointp->description);
     }
   }
 
@@ -1646,19 +1645,19 @@ static void kml_waypt_pr(const Waypoint* waypointp)
   // Icon - but only if it looks like a URL.
   icon = opt_deficon ? opt_deficon : waypointp->icon_descr;
   if (icon.contains("://")) {
-    writer->writeStartElement("Style");
-    writer->writeStartElement("IconStyle");
-    writer->writeStartElement("Icon");
-    writer->writeTextElement("href", icon);
+    writer->writeStartElement(QStringLiteral("Style"));
+    writer->writeStartElement(QStringLiteral("IconStyle"));
+    writer->writeStartElement(QStringLiteral("Icon"));
+    writer->writeTextElement(QStringLiteral("href"), icon);
     writer->writeEndElement(); // Close Icon tag
     writer->writeEndElement(); // Close IconStyle tag
     writer->writeEndElement(); // Close Style tag
   } else {
-    writer->writeTextElement("styleUrl", "#waypoint");
+    writer->writeTextElement(QStringLiteral("styleUrl"), QStringLiteral("#waypoint"));
   }
 
   // Location
-  writer->writeStartElement("Point");
+  writer->writeStartElement(QStringLiteral("Point"));
   kml_output_positioning(false);
   kml_write_coordinates(waypointp);
   writer->writeEndElement(); // Close Point tag
@@ -1713,8 +1712,8 @@ static void kml_mt_simple_array(const route_head* header,
                                 wp_field member)
 {
   queue* elem, *tmp;
-  writer->writeStartElement("gx:SimpleArrayData");
-  writer->writeAttribute("name", name);
+  writer->writeStartElement(QStringLiteral("gx:SimpleArrayData"));
+  writer->writeAttribute(QStringLiteral("name"), name);
 
   QUEUE_FOR_EACH(&header->waypoint_list, elem, tmp) {
 
@@ -1722,19 +1721,19 @@ static void kml_mt_simple_array(const route_head* header,
 
     switch (member) {
     case fld_power:
-      writer->writeTextElement("gx:value", QString::number(wpt->power, 'f', 1));
+      writer->writeTextElement(QStringLiteral("gx:value"), QString::number(wpt->power, 'f', 1));
       break;
     case fld_cadence:
-      writer->writeTextElement("gx:value", QString::number(wpt->cadence));
+      writer->writeTextElement(QStringLiteral("gx:value"), QString::number(wpt->cadence));
       break;
     case fld_depth:
-      writer->writeTextElement("gx:value", QString::number(wpt->depth, 'f', 1));
+      writer->writeTextElement(QStringLiteral("gx:value"), QString::number(wpt->depth, 'f', 1));
       break;
     case fld_heartrate:
-      writer->writeTextElement("gx:value", QString::number(wpt->heartrate));
+      writer->writeTextElement(QStringLiteral("gx:value"), QString::number(wpt->heartrate));
       break;
     case fld_temperature:
-      writer->writeTextElement("gx:value", QString::number(wpt->temperature, 'f', 1));
+      writer->writeTextElement(QStringLiteral("gx:value"), QString::number(wpt->temperature, 'f', 1));
       break;
     default:
       fatal("Bad member type");
@@ -1790,10 +1789,10 @@ static void kml_mt_hdr(const route_head* header)
     return;
   }
 
-  writer->writeStartElement("Placemark");
-  writer->writeOptionalTextElement("name", header->rte_name);
-  writer->writeTextElement("styleUrl", "#multiTrack");
-  writer->writeStartElement("gx:Track");
+  writer->writeStartElement(QStringLiteral("Placemark"));
+  writer->writeOptionalTextElement(QStringLiteral("name"), header->rte_name);
+  writer->writeTextElement(QStringLiteral("styleUrl"), QStringLiteral("#multiTrack"));
+  writer->writeStartElement(QStringLiteral("gx:Track"));
   kml_output_positioning(false);
 
   QUEUE_FOR_EACH(&header->waypoint_list, elem, tmp) {
@@ -1801,9 +1800,9 @@ static void kml_mt_hdr(const route_head* header)
 
     if (tpt->GetCreationTime().isValid()) {
       QString time_string = tpt->CreationTimeXML();
-      writer->writeOptionalTextElement("when", time_string);
+      writer->writeOptionalTextElement(QStringLiteral("when"), time_string);
     } else {
-      writer->writeStartElement("when");
+      writer->writeStartElement(QStringLiteral("when"));
       writer->writeEndElement(); // Close when tag
     }
   }
@@ -1813,13 +1812,13 @@ static void kml_mt_hdr(const route_head* header)
     Waypoint* tpt = (Waypoint*)elem;
 
     if (kml_altitude_known(tpt)) {
-      writer->writeTextElement("gx:coord",
+      writer->writeTextElement(QStringLiteral("gx:coord"),
                                QString::number(tpt->longitude, 'f', precision) + QString(" ") +
                                QString::number(tpt->latitude, 'f', precision) + QString(" ") +
                                QString::number(tpt->altitude, 'f', 2)
                               );
     } else {
-      writer->writeTextElement("gx:coord",
+      writer->writeTextElement(QStringLiteral("gx:coord"),
                                QString::number(tpt->longitude, 'f', precision) + QString(" ") +
                                QString::number(tpt->latitude, 'f', precision)
                               );
@@ -1846,9 +1845,9 @@ static void kml_mt_hdr(const route_head* header)
 
   if (has_cadence || has_depth || has_heartrate || has_temperature ||
       has_power) {
-    writer->writeStartElement("ExtendedData");
-    writer->writeStartElement("SchemaData");
-    writer->writeAttribute("schemaUrl", "#schema");
+    writer->writeStartElement(QStringLiteral("ExtendedData"));
+    writer->writeStartElement(QStringLiteral("SchemaData"));
+    writer->writeAttribute(QStringLiteral("schemaUrl"), QStringLiteral("#schema"));
 
     if (has_cadence) {
       kml_mt_simple_array(header, kmt_cadence, fld_cadence);
@@ -1920,12 +1919,12 @@ void kml_write_AbstractView()
     route_disp_all(NULL, NULL, kml_add_to_bounds);
   }
 
-  writer->writeStartElement("LookAt");
+  writer->writeStartElement(QStringLiteral("LookAt"));
 
   if (kml_time_min.isValid() || kml_time_max.isValid()) {
-    writer->writeStartElement("gx:TimeSpan");
+    writer->writeStartElement(QStringLiteral("gx:TimeSpan"));
     if (kml_time_min.isValid()) {
-      writer->writeTextElement("begin", kml_time_min.toPrettyString());
+      writer->writeTextElement(QStringLiteral("begin"), kml_time_min.toPrettyString());
     }
     if (kml_time_max.isValid()) {
       gpsbabel::DateTime time_max;
@@ -1937,7 +1936,7 @@ void kml_write_AbstractView()
       // ensure the right edge of that time slider includes us.
       //
       time_max = realtime_positioning ? kml_time_max.addSecs(600) : kml_time_max;
-      writer->writeTextElement("end", time_max.toPrettyString());
+      writer->writeTextElement(QStringLiteral("end"), time_max.toPrettyString());
     }
     writer->writeEndElement(); // Close gx:TimeSpan tag
   }
@@ -1949,8 +1948,8 @@ void kml_write_AbstractView()
     kml_bounds.min_lon = -kml_bounds.max_lon;
   }
 
-  writer->writeTextElement("longitude", QString::number((kml_bounds.min_lon + kml_bounds.max_lon) / 2, 'f', precision));
-  writer->writeTextElement("latitude", QString::number((kml_bounds.min_lat + kml_bounds.max_lat) / 2, 'f', precision));
+  writer->writeTextElement(QStringLiteral("longitude"), QString::number((kml_bounds.min_lon + kml_bounds.max_lon) / 2, 'f', precision));
+  writer->writeTextElement(QStringLiteral("latitude"), QString::number((kml_bounds.min_lat + kml_bounds.max_lat) / 2, 'f', precision));
 
   // It turns out the length of the diagonal of the bounding box gives us a
   // reasonable guess for setting the camera altitude.
@@ -1960,7 +1959,7 @@ void kml_write_AbstractView()
   if (bb_size < 1000) {
     bb_size = 1000;
   }
-  writer->writeTextElement("range", QString::number(bb_size * 1.3, 'f', 6));
+  writer->writeTextElement(QStringLiteral("range"), QString::number(bb_size * 1.3, 'f', 6));
 
   writer->writeEndElement(); // Close LookAt tag
 }
@@ -1969,10 +1968,10 @@ static
 void kml_mt_array_schema(const char* field_name, const char* display_name,
                          const char* type)
 {
-  writer->writeStartElement("gx:SimpleArrayField");
-  writer->writeAttribute("name", field_name);
-  writer->writeAttribute("type", type);
-  writer->writeTextElement("displayName", display_name);
+  writer->writeStartElement(QStringLiteral("gx:SimpleArrayField"));
+  writer->writeAttribute(QStringLiteral("name"), field_name);
+  writer->writeAttribute(QStringLiteral("type"), type);
+  writer->writeTextElement(QStringLiteral("displayName"), display_name);
   writer->writeEndElement(); // Close gx:SimpleArrayField tag
 }
 
@@ -1997,24 +1996,24 @@ void kml_write()
   // to include just enough whitespace between <xml/> and <gpx...> to pass
   // diff -w.  It's here for now to shim compatibility with our zillion
   // reference files, but this blank link can go away some day.
-  writer->writeCharacters("\n");
+  writer->writeCharacters(QStringLiteral("\n"));
 
   writer->setAutoFormatting(true);
 
-  writer->writeStartElement("kml");
-  writer->writeAttribute("xmlns", "http://www.opengis.net/kml/2.2");
-  writer->writeAttribute("xmlns:gx","http://www.google.com/kml/ext/2.2");
+  writer->writeStartElement(QStringLiteral("kml"));
+  writer->writeAttribute(QStringLiteral("xmlns"), QStringLiteral("http://www.opengis.net/kml/2.2"));
+  writer->writeAttribute(QStringLiteral("xmlns:gx"), QStringLiteral("http://www.google.com/kml/ext/2.2"));
 
-  writer->writeStartElement("Document");
+  writer->writeStartElement(QStringLiteral("Document"));
 
   if (realtime_positioning) {
-    writer->writeTextElement("name", "GPS position");
+    writer->writeTextElement(QStringLiteral("name"), QStringLiteral("GPS position"));
   } else {
-    writer->writeTextElement("name", "GPS device");
+    writer->writeTextElement(QStringLiteral("name"), QStringLiteral("GPS device"));
   }
 
   if (current_time().isValid()) {
-    writer->writeTextElement("snippet", QString("Created ") +
+    writer->writeTextElement(QStringLiteral("snippet"), QStringLiteral("Created ") +
                              current_time().toString());
   }
 
@@ -2042,8 +2041,8 @@ void kml_write()
   kml_write_bitmap_style(kmlpt_waypoint, ICON_WPT, NULL);
 
   if (track_waypt_count() || route_waypt_count()) {
-    writer->writeStartElement("Style");
-    writer->writeAttribute("id", "lineStyle");
+    writer->writeStartElement(QStringLiteral("Style"));
+    writer->writeAttribute(QStringLiteral("id"), QStringLiteral("lineStyle"));
     kml_output_linestyle(opt_line_color, line_width);
     writer->writeEndElement(); // Close Style tag
   }
@@ -2057,8 +2056,8 @@ void kml_write()
       traits->trait_power ||
       traits->trait_temperature ||
       traits->trait_depth) {
-    writer->writeStartElement("Schema");
-    writer->writeAttribute("id", "schema");
+    writer->writeStartElement(QStringLiteral("Schema"));
+    writer->writeAttribute(QStringLiteral("id"), QStringLiteral("schema"));
 
     if (traits->trait_heartrate) {
       kml_mt_array_schema(kmt_heartrate, "Heart Rate", "int");
@@ -2080,8 +2079,8 @@ void kml_write()
 
   if (waypt_count()) {
     if (!realtime_positioning) {
-      writer->writeStartElement("Folder");
-      writer->writeTextElement("name", "Waypoints");
+      writer->writeStartElement(QStringLiteral("Folder"));
+      writer->writeTextElement(QStringLiteral("name"), QStringLiteral("Waypoints"));
     }
 
     waypt_disp_all(kml_waypt_pr);
@@ -2094,8 +2093,8 @@ void kml_write()
   // Output trackpoints
   if (track_waypt_count()) {
     if (!realtime_positioning) {
-      writer->writeStartElement("Folder");
-      writer->writeTextElement("name", "Tracks");
+      writer->writeStartElement(QStringLiteral("Folder"));
+      writer->writeTextElement(QStringLiteral("name"), QStringLiteral("Tracks"));
     }
 
     kml_init_color_sequencer(track_count());
@@ -2114,8 +2113,8 @@ void kml_write()
   // Output routes
   if (route_waypt_count()) {
     if (!realtime_positioning) {
-      writer->writeStartElement("Folder");
-      writer->writeTextElement("name", "Routes");
+      writer->writeStartElement(QStringLiteral("Folder"));
+      writer->writeTextElement(QStringLiteral("name"), QStringLiteral("Routes"));
 
       kml_init_color_sequencer(route_count());
       route_disp_all(kml_route_hdr,

diff --git a/mapfactor.cc b/mapfactor.cc
index ed169809535b97616aae97b9d202a9d8ba740c62..58cdd5296ab21b7d7a0159666456adeed6c15a68 100644 (file)
--- a/mapfactor.cc
+++ b/mapfactor.cc
@@ -126,19 +126,19 @@ mapfactor_wr_deinit()
 static void
 mapfactor_waypt_pr(const Waypoint* waypointp)
 {
-  writer->writeStartElement("item");
+  writer->writeStartElement(QStringLiteral("item"));
 
-  writer->writeAttribute("name", waypointp->shortname);
-  writer->writeAttribute("lat", QString::number(waypointp->latitude * milliarcseconds, 'f', 0));
-  writer->writeAttribute("lon", QString::number(waypointp->longitude * milliarcseconds, 'f', 0));
+  writer->writeAttribute(QStringLiteral("name"), waypointp->shortname);
+  writer->writeAttribute(QStringLiteral("lat"), QString::number(waypointp->latitude * milliarcseconds, 'f', 0));
+  writer->writeAttribute(QStringLiteral("lon"), QString::number(waypointp->longitude * milliarcseconds, 'f', 0));
   writer->writeEndElement();
 }
 
 static void
 mapfactor_write()
 {
-  writer->writeStartElement("favourites");
-  writer->writeAttribute("version", "1");
+  writer->writeStartElement(QStringLiteral("favourites"));
+  writer->writeAttribute(QStringLiteral("version"), QStringLiteral("1"));
   // TODO: This could be moved to wr_init, but the pre GPX version put the two
   // lines above this, so mimic that behaviour exactly.
   writer->setAutoFormatting(true);

diff --git a/src/core/datetime.h b/src/core/datetime.h
index d79096865c57c03f110821898d84879e5d58b32d..18a3eaae9aad50355058015febdc8d5b81796b56 100644 (file)
--- a/src/core/datetime.h
+++ b/src/core/datetime.h
@@ -25,6 +25,7 @@
 
 #include <QtCore/QtGlobal>
 #include <QtCore/QDateTime>
+#include <QtCore/QString>
 
 // As this code began in C, we have several hundred places that set and
 // read creation_time as a time_t.  Provide some operator overloads to make
@@ -76,42 +77,14 @@ public:
     return date().isValid() && time().isValid() && toTime_t() > 0;
   }
 
-
-  // Qt 4.6 and under doesn't have msecsTo.  Fortunately, it's easy to
-  // provide.  It's a 64-bit because if the times aren't on the same day,
-  // the returned value can be quite large.
-  qint64 msecsTo(const QDateTime &dt) const {
-    QDateTime dtutc = dt.toUTC();
-    QDateTime thisutc = toUTC();
-    qint64 days = thisutc.daysTo(dtutc);
-    qint64 msecs = thisutc.time().msecsTo(dtutc.time());
-    return days * (1000 * 3600 * 24) + msecs;
-  }
-
-  // Qt 4.6 and under doesn't have toMSecsSinceEpoch.
-  qint64 toMSecsSinceEpoch() const {
-    QDateTime epoch = QDateTime(QDate(1970, 1, 1), QTime(0, 0, 0, 0), Qt::UTC);
-    return -msecsTo(epoch);
-  }
-
-  // This was added in Qt 4.7, but it's easy enough to knock out here.
-  void setMSecsSinceEpoch(qint64 msecs) {
-    int ddays = msecs / 86400000;
-    msecs %= 86400000;
-    setDate(QDate(1970, 1, 1).addDays(ddays));
-    setTime(QTime(0,0).addMSecs(msecs));
-  }
-
   // Like toString, but with subsecond time that's included only when
   // the trailing digits aren't .000.  Always UTC.
   QString toPrettyString() const {
-    const char* format;
     if (time().msec()) {
-      format = "yyyy-MM-ddTHH:mm:ss.zzzZ";
+      return toUTC().toString(QStringLiteral("yyyy-MM-ddTHH:mm:ss.zzzZ"));
     } else {
-      format = "yyyy-MM-ddTHH:mm:ssZ";
+      return toUTC().toString(QStringLiteral("yyyy-MM-ddTHH:mm:ssZ"));
     }
-    return toUTC().toString(format);
   }
 };
 

diff --git a/src/core/xmlstreamwriter.cc b/src/core/xmlstreamwriter.cc
index 615d126bf0ebcd484ef35abc02b99af1d09cbd92..70c59fc214c83c7b0f60cba0cddfb411fd7e5091 100644 (file)
--- a/src/core/xmlstreamwriter.cc
+++ b/src/core/xmlstreamwriter.cc
@@ -20,6 +20,7 @@
 #include "src/core/xmlstreamwriter.h"
 
 #include <QtCore/QFile>
+#include <QtCore/QString>
 #include <QtCore/QTextCodec>
 #include <QtCore/QXmlStreamWriter>
 
@@ -84,7 +85,7 @@ XmlStreamWriter::XmlStreamWriter(QFile* f) : QXmlStreamWriter(f)
 // We must overide the encoding, we don't want to use XmlTextCode::name().
 void XmlStreamWriter::writeStartDocument()
 {
-  writeProcessingInstruction("xml version=\"1.0\" encoding=\"UTF-8\"");
+  writeProcessingInstruction(QStringLiteral("xml version=\"1.0\" encoding=\"UTF-8\""));
 }
 
 // Dont emit the attribute if there's nothing interesting in it.

diff --git a/xol.cc b/xol.cc
index 211df2d301a5f7d0e42bb1c47c5df0296ae632b6..5ae3e2381ed59b59d319dcd67b6d9f64d20f905e 100644 (file)
--- a/xol.cc
+++ b/xol.cc
@@ -199,34 +199,34 @@ static void xol_waypt_disp_cb(const Waypoint* wpt) {
   if (!GPS_Math_WGS84_To_Swiss_EN(wpt->latitude, wpt->longitude, &x, &y)) {
     xol_fatal_outside(wpt);
   }
-  writer->writeStartElement("shape");
-  writer->writeAttribute("type", "waypoint");
-  writer->writeAttribute("name", name);
-  writer->writeAttribute("comment", wpt->notes);
-  writer->writeAttribute("icon", wpt->icon_descr);
+  writer->writeStartElement(QStringLiteral("shape"));
+  writer->writeAttribute(QStringLiteral("type"), QStringLiteral("waypoint"));
+  writer->writeAttribute(QStringLiteral("name"), name);
+  writer->writeAttribute(QStringLiteral("comment"), wpt->notes);
+  writer->writeAttribute(QStringLiteral("icon"), wpt->icon_descr);
 
   if (wpt->creation_time.isValid()) {
-    writer->writeAttribute("timestamp", wpt->CreationTimeXML());
+    writer->writeAttribute(QStringLiteral("timestamp"), wpt->CreationTimeXML());
   }
   if (wpt->altitude != unknown_alt) {
-    writer->writeAttribute("alt", QString::number(wpt->altitude, 'f', 6));
+    writer->writeAttribute(QStringLiteral("alt"), QString::number(wpt->altitude, 'f', 6));
   }
-  writer->writeStartElement("points");
-  writer->writeStartElement("point");
-  writer->writeAttribute("x", QString::number(x));
-  writer->writeAttribute("y", QString::number(y));
+  writer->writeStartElement(QStringLiteral("points"));
+  writer->writeStartElement(QStringLiteral("point"));
+  writer->writeAttribute(QStringLiteral("x"), QString::number(x));
+  writer->writeAttribute(QStringLiteral("y"), QString::number(y));
   writer->writeEndElement();  // point
   writer->writeEndElement();  // points
   writer->writeEndElement();  // shape
 }
 
 static void xol_track_hdr_disp_cb(const route_head*) {
-  writer->writeStartElement("shape");
-  writer->writeAttribute("type", "polyline");
-  writer->writeAttribute("lineSize", "3");
-  writer->writeAttribute("lineColor", "#e60000");
-  writer->writeAttribute("lineStyle", "solid");
-  writer->writeStartElement("waypoints");
+  writer->writeStartElement(QStringLiteral("shape"));
+  writer->writeAttribute(QStringLiteral("type"), QStringLiteral("polyline"));
+  writer->writeAttribute(QStringLiteral("lineSize"), QStringLiteral("3"));
+  writer->writeAttribute(QStringLiteral("lineColor"), QStringLiteral("#e60000"));
+  writer->writeAttribute(QStringLiteral("lineStyle"), QStringLiteral("solid"));
+  writer->writeStartElement(QStringLiteral("waypoints"));
 }
 
 static void xol_track_tlr_disp_cb(const route_head*) {
@@ -241,19 +241,19 @@ static void xol_trkpt_disp_cb(const Waypoint* wpt) {
     xol_fatal_outside(wpt);
   }
 
-  writer->writeStartElement("shape");
-  writer->writeAttribute("type", "waypoint");
+  writer->writeStartElement(QStringLiteral("shape"));
+  writer->writeAttribute(QStringLiteral("type"), QStringLiteral("waypoint"));
   if (wpt->creation_time.isValid()) {
-    writer->writeAttribute("timestamp", wpt->CreationTimeXML());
+    writer->writeAttribute(QStringLiteral("timestamp"), wpt->CreationTimeXML());
   }
   if (wpt->altitude != unknown_alt) {
-    writer->writeAttribute("alt", QString::number(wpt->altitude, 'f'));
+    writer->writeAttribute(QStringLiteral("alt"), QString::number(wpt->altitude, 'f'));
   }
 
-  writer->writeStartElement("points");
-  writer->writeStartElement("point");
-  writer->writeAttribute("x", QString::number(x));
-  writer->writeAttribute("y", QString::number(y));
+  writer->writeStartElement(QStringLiteral("points"));
+  writer->writeStartElement(QStringLiteral("point"));
+  writer->writeAttribute(QStringLiteral("x"), QString::number(x));
+  writer->writeAttribute(QStringLiteral("y"), QString::number(y));
   writer->writeEndElement();  // point
   writer->writeEndElement();  // points
   writer->writeEndElement();  // shape
@@ -278,14 +278,14 @@ static void xol_write() {
   }
 
   writer->setAutoFormatting(true);
-  writer->writeStartElement("overlays");
-  writer->writeStartElement("overlay");
-  writer->writeAttribute("version", "1.0");
-  writer->writeStartElement("center");
-  writer->writeAttribute("x", QString::number(x));
-  writer->writeAttribute("y", QString::number(y));
+  writer->writeStartElement(QStringLiteral("overlays"));
+  writer->writeStartElement(QStringLiteral("overlay"));
+  writer->writeAttribute(QStringLiteral("version"), QStringLiteral("1.0"));
+  writer->writeStartElement(QStringLiteral("center"));
+  writer->writeAttribute(QStringLiteral("x"), QString::number(x));
+  writer->writeAttribute(QStringLiteral("y"), QString::number(y));
   writer->writeEndElement();  // center
-  writer->writeStartElement("shapes");
+  writer->writeStartElement(QStringLiteral("shapes"));
 
   waypt_disp_all(xol_waypt_disp_cb);
   track_disp_all(xol_track_hdr_disp_cb, xol_track_tlr_disp_cb,